const U = {}

/**
 * 判断是否为空
 * @param obj
 * @returns {boolean}
 */
U.isEmpty = function(obj) {
  if (typeof (obj) == 'undefined' || obj == null || obj == 'null' || obj == 'undefined' || (typeof (obj) == 'string' && obj == '')) {
    return true
  }
  return false
}

/**
 * 判断对象是否为空
 * @param obj
 * @returns {boolean}
 */
U.isObjEmpty = function(obj) {
  if (Object.keys(obj).length == 0) {
    return false
  } else {
    return true
  }
}

/**
 * 将对象属性 null 转 空
 * @param obj 操作的对象
 * @param delAttr  要把obj 中删除的属性数组
 * @returns {*}
 */
U.objAttrNullToString = function(obj, delAttr = []) {
  for (var keys in obj) {
    var index = delAttr.indexOf(keys)
    if (index === -1) {
      if (U.isEmpty(obj[keys])) {
        obj[keys] = ''
      }
    } else {
      delete obj[delAttr[index]]
    }
  }
  return obj
}

/**
 * 字符串截取
 * @param start
 * @param end
 * @param str
 * @returns {*}
 */
U.subStr = function(start, end, str) {
  if (U.isEmpty(str)) {
    return ''
  }
  if (typeof (str) == 'string') {
    var len = str.length
    var s = ''
    if (len < end) {
      return str
    } else {
      for (var i = 0; i < end; i++) {
        s = s + str[i]
      }
      return s + '...'
    }
  } else {
    return str
  }
}

/**
 * null 转 字符串
 * @param data
 * @param key
 * @returns {*}
 */
U.nullToString = function(data, key) {
  if (typeof data == 'object') {
    const obj = data
    try {
      const value = eval('obj.' + key)
      // const value = data[key]
      if (U.isEmpty(value)) {
        return ''
      }

      if (typeof value == 'boolean') {
        if (value == true || value == 'true') {
          return '是'
        } else {
          return '否'
        }
      }
      return value
    } catch (err) {
      return ''
    }
  }
  return ''
}

/**
 * 格式化日期
 * @param date
 * @param fmt
 * @returns {*}
 */
U.formatDate = function(date, fmt) {
  if (/(y+)/.test(fmt)) {
    fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length))
  }
  const o = {
    'M+': date.getMonth() + 1,
    'd+': date.getDate(),
    'h+': date.getHours(),
    'm+': date.getMinutes(),
    's+': date.getSeconds()
  }
  for (const k in o) {
    if (new RegExp(`(${k})`).test(fmt)) {
      const str = o[k] + ''
      fmt = fmt.replace(RegExp.$1, (RegExp.$1.length === 1) ? str : ('00' + str).substr(str.length))
    }
  }
  return fmt
}

/**
 * 将截取日期
 * @param date
 * @returns {string}
 */
U.cutDate = function(date) {
  if (U.isEmpty(date)) {
    return ''
  }
  var newDate = date.substring(0, 10)
  return newDate
}

/**
 * 计算天数
 * @param sDate1
 * @param sDate2
 * @returns {*}
 * @constructor
 */
U.DateDiff = function(sDate1, sDate2) {
  if (U.isEmpty(sDate1)) {
    return ''
  }
  if (U.isEmpty(sDate2)) {
    return ''
  }

  sDate1 = U.cutDate(sDate1)
  sDate2 = U.cutDate(sDate2)

  var aDate, oDate1, oDate2, iDays
  aDate = sDate1.split('-')
  oDate1 = new Date(aDate[1] + '-' + aDate[2] + '-' + aDate[0]) // 转换为9-25-2018格式
  aDate = sDate2.split('-')
  oDate2 = new Date(aDate[1] + '-' + aDate[2] + '-' + aDate[0])
  iDays = parseInt(Math.abs(oDate1 - oDate2) / 1000 / 60 / 60 / 24) // 把相差的毫秒数转换为天数
  return iDays + 1
}

/**
 * 首字母 转 大写字母 和  大写转小写
 * @param first
 * @param rest
 * @param lowerRest
 * @returns {string}
 */
U.capitalize = function([first, ...rest], lowerRest = false) {
  return first.toUpperCase() + (lowerRest ? rest.join('').toLowerCase() : rest.join(''))
}

// 首字母 转 小写字母 和  小写转大写
U.lowercase = function([first, ...rest], lowerRest = false) {
  return first.toLowerCase() + (lowerRest ? rest.join('').toLowerCase() : rest.join(''))
}

/**
 * 去除数组中 空值
 * @param arrVal
 * @returns {*}
 */
U.removeEmptyArrayEle = function(arrVal) {
  var arr = null
  if (U.isEmpty(arrVal)) {
    arr = []
  } else {
    arr = arrVal.split(',')
    for (var i = 0; i < arr.length; i++) {
      if (arr[i] == undefined) {
        arr.splice(i, 1)
        i = i - 1 // i - 1 ,因为空元素在数组下标 2 位置，删除空之后，后面的元素要向前补位，
        // 这样才能真正去掉空元素,觉得这句可以删掉的连续为空试试，然后思考其中逻辑
      }
    }
  }

  return arr
}

/**
 * 扩展Array方法, 去除数组中空白数据
 * @param value
 * @returns {Array}
 */
U.notemptyT = function(value) {
  var arr = []
  value.map(function(val, index) {
    // 过滤规则为，不为空串、不为null、不为undefined，也可自行修改
    if (val !== '' && val != undefined) {
      arr.push(val)
    }
  })
  return arr
}

/**
 * obj 深度拷贝
 * @param obj
 * @returns {*}
 */
U.deepCopy = function(obj) {
  if (obj === null) return null
  if (typeof obj !== 'object') return obj
  if (obj.constructor === Date) return new Date(obj)
  if (obj.constructor === RegExp) return new RegExp(obj)
  var newObj = new obj.constructor() // 保持继承链
  for (var key in obj) {
    if (obj.hasOwnProperty(key)) { // 不遍历其原型链上的属性
      var val = obj[key]
      // newObj[key] = typeof val === 'object' ? arguments.callee(val) : val; // 使用arguments.callee解除与函数名的耦合
      newObj[key] = val
    }
  }
  return newObj
}

/**
 * 表格根据页面排序
 * @param pageSize 显示的条数
 * @param pageNumber 显示的页码
 * @param total 总数
 * @param data 显示的数据
 */
U.tableNumber = function(pageSize, pageNumber, total, data) {
  // 开始条数
  var start = (pageNumber - 1) * pageSize + 1
  // 结束条数
  var end = start + (pageSize - 1)
  if (end > total) {
    end = total
  }
  var pageListLen = data.length
  for (var i = 0; i < pageListLen; i++) {
    data[i].index = start + i
  }
}

/**
 * 判断是否用微信内置浏览器打开
 * @returns {boolean}
 */
U.isWeChat = function() {
  // MicroMessenger
  var userAgent = navigator.userAgent.match().input
  if (userAgent.indexOf('MicroMessenger') > 0) {
    return true
  } else {
    return false
  }
}

/**
 * 检查访问设备
 * @returns {boolean}
 */
U.isPC = function() {
  var userAgentInfo = navigator.userAgent.toLowerCase()
  var Agents = new Array('android', 'iphone', 'symbianOS', 'windows phone', 'ipad', 'ipod')
  var flag = true
  for (var v = 0; v < Agents.length; v++) {
    if (userAgentInfo.indexOf(Agents[v]) > 0) { flag = false; break }
  }
  return flag
}

/**
 *  钱 添加 千位符
 * @param num
 * @returns {string}
 */
U.toThousands = function(num) {
  if (!num) return '0.00'
  var info = parseFloat(num).toFixed(2).toString().split('.')
  num = info[0]
  var result = ''
  while (num.length > 3) {
    result = ',' + num.slice(-3) + result
    num = num.slice(0, num.length - 3)
  }
  if (num) { result = num + result }
  info[0] = result
  return info.join('.')
}

/**
 * 元转分 == 分转元
 * @param money  需要转的值
 * @param symbol  需要转的符号  / 和 *
 * @returns {*}
 */
U.moneyUtilTransform = function(money, symbol = '/') {
  if (this.isEmpty(money)) {
    return '0.00'
  } else {
    var num = Number(money)
    if (isNaN(num) || num === 0) {
      return '0.00'
    } else {
      // 存储转换后得价格
      var tempMoney = 0
      // 转换得基数
      var baseNum = 100
      switch (symbol) {
        case '/':
          tempMoney = parseFloat(money / baseNum)
          break
        case '*':
          tempMoney = parseFloat(money * baseNum)
          break
      }
      if (symbol === '/') {
        return U.toThousands(tempMoney)
      } else {
        return tempMoney
      }
    }
  }
}

/**
 *  数值保留N位小数, 四舍五入
 * @param num 需要转换的数值
 * @param digit  需要保留的位数 默认保存六位
 * @returns {*}
 */
U.retainNumber = function(num, digit = 6) {
  // 判断是否为空
  if (U.isEmpty(num)) {
    return num
  }
  var f = parseFloat(num)
  if (isNaN(f) || f.toString().length !== num.toString().length) {
    return num
  } else {
    return f.toFixed(digit)
  }
}

/**
 * 判断两个对象是否相等
 * @param oldData 旧对象
 * @param newData 新对象
 * @returns {boolean}
 */
U.equalsObj = function(oldData, newData) {
// 类型为基本类型时,如果相同,则返回true
  if (oldData === newData) return true
  // 类型为对象并且元素个数相同
  if (U.isObject(oldData) && U.isObject(newData) && Object.keys(oldData).length === Object.keys(newData).length) {
    // 遍历所有对象中所有属性,判断元素是否相同
    for (const key in oldData) {
      if (oldData.hasOwnProperty(key)) {
        if (!U.equalsObj(oldData[key], newData[key])) { // 对象中具有不相同属性 返回false
          return false
        }
      }
    }
    // 类型为数组并且数组长度相同
  } else if (U.isArray(oldData) && U.isArray(oldData) && oldData.length === newData.length) {

    for (let i = 0, length = oldData.length; i < length; i++) {

      // 如果数组元素中具有不相同元素,返回false
      if (!U.equalsObj(oldData[i], newData[i]))
      { return false }
    }
  } else {
    // 其它类型,均返回false
    return false
  }

  // 走到这里,说明数组或者对象中所有元素都相同,返回true
  return true
}

/**
 * 判断是否为对象
 * @param obj
 * @returns {boolean}
 */
U.isObject = function(obj) {
  return Object.prototype.toString.call(obj) === '[object Object]'
}

/**
 * 判断是否为数组
 * @param arr 数据
 * @returns {boolean}
 */
U.isArray = function(arr) {
  return Object.prototype.toString.call(arr) === '[object Array]'
}

export default U
